plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/expression/RewriteCoalesce.java (2)

38-46: Simplify pattern: the capture is unnecessary.

The CALL capture is not needed since the call parameter passed to rewrite() is the same matched Call object. You can remove the capture and use call directly in the loop.

♻️ Suggested simplification

 public class RewriteCoalesce
         implements ConnectorExpressionRule<Call, ParameterizedExpression>
 {
-    private static final Capture<Call> CALL = newCapture();
     private final Pattern<Call> pattern;
 
     public RewriteCoalesce()
     {
         this.pattern = call()
-                .with(functionName().matching(name -> name.equals(COALESCE_FUNCTION_NAME)))
-                .capturedAs(CALL);
+                .with(functionName().equalTo(COALESCE_FUNCTION_NAME));
     }

Also update the imports to remove Capture and newCapture if no longer used.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/expression/RewriteCoalesce.java`
around lines 38 - 46, Remove the unnecessary Capture and simplify the pattern in
RewriteCoalesce: delete the static CALL and its newCapture() usage, change the
pattern to just call().with(functionName().matching(name ->
name.equals(COALESCE_FUNCTION_NAME))), and in the rewrite(Call call, ...)
implementation use the provided call parameter instead of using CALL.get(). Also
remove unused imports Capture and newCapture from the file.

---

57-72: Remove redundant verify and use call parameter directly.

1. Line 61 uses captures.get(CALL).getArguments() but call.getArguments() is equivalent and simpler.
2. The verify at line 71 is redundant—if line 57 passes with N arguments, the loop will produce exactly N rewritten arguments (or return early on failure).

♻️ Suggested simplification

     `@Override`
     public Optional<ParameterizedExpression> rewrite(Call call, Captures captures, RewriteContext<ParameterizedExpression> context)
     {
         verify(call.getArguments().size() >= 2, "Function 'coalesce' expects more than or equals to two arguments");
 
         ImmutableList.Builder<String> rewrittenArguments = ImmutableList.builderWithExpectedSize(call.getArguments().size());
         ImmutableList.Builder<QueryParameter> parameters = ImmutableList.builder();
-        for (ConnectorExpression expression : captures.get(CALL).getArguments()) {
+        for (ConnectorExpression expression : call.getArguments()) {
             Optional<ParameterizedExpression> rewritten = context.defaultRewrite(expression);
             if (rewritten.isEmpty()) {
                 return Optional.empty();
             }
             rewrittenArguments.add(rewritten.get().expression());
             parameters.addAll(rewritten.get().parameters());
         }
 
         List<String> arguments = rewrittenArguments.build();
-        verify(arguments.size() >= 2, "Function 'coalesce' expects more than or equals to two arguments");
         return Optional.of(new ParameterizedExpression("COALESCE(%s)".formatted(join(",", arguments)), parameters.build()));
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/expression/RewriteCoalesce.java`
around lines 57 - 72, In RewriteCoalesce, simplify the argument rewriting loop
by iterating over call.getArguments() instead of
captures.get(CALL).getArguments(), set
ImmutableList.builderWithExpectedSize(call.getArguments().size()) for
rewrittenArguments, and remove the redundant verify(arguments.size() >= 2) check
at the end (the initial verify on call.getArguments().size() already guarantees
the count or early-return on rewrite failure); keep the existing behavior of
returning Optional.empty() on rewrite failure and constructing the final
ParameterizedExpression("COALESCE(%s)".formatted(join(",", arguments)),
parameters.build()).